package com.xrh.xdemo.service.service;


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xrh.core.bean.CommonPage;
import com.xrh.core.bean.CommonResult;
import com.xrh.core.exceptions.BusinessException;
import com.xrh.core.utils.XAssert;
import com.xrh.xdemo.api.constants.MenuTypeConstants;
import com.xrh.xdemo.api.dto.entity.MenuDTO;
import com.xrh.xdemo.api.dto.entity.MenuTreeDTO;
import com.xrh.xdemo.api.dto.entity.SysUserDTO;
import com.xrh.xdemo.api.request.addRequest.MenuAddRequest;
import com.xrh.xdemo.api.request.queryRequest.MenuQueryRequest;
import com.xrh.xdemo.api.request.updateRequest.MenuUpdateRequest;
import com.xrh.xdemo.service.aspects.OperateTraceAspect;
import com.xrh.xdemo.service.entity.MenuEntity;
import com.xrh.xdemo.service.mapper.MenuMapper;
import com.xrh.xdemo.service.utils.LoginUtils;
import com.xrh.xdemo.service.utils.SeqNoUtils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.collection.CollStreamUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class MenuService {

	@Resource
	MenuMapper menuMapper;
	
	@Resource
	RoleVsMenuService roleVsMenuService;
	
	@Resource
	SysRoleService sysRoleService;
	
	/**
	 * @function 初始化系统菜单(不可删除)
	 * @author 肖荣辉
	 * @date 2023年12月17日
	*/
	@SuppressWarnings("unused")
	public void initSysMenu() {
		
		log.info("初始化系统菜单start");
		
		//系统管理菜单(顶部)
		MenuEntity sys_manager_top_menu = initNode(MenuTypeConstants.MENU, "系统管理", "sys_manager_top_menu", "icon-windows");
		
		//系统管理菜单(顶部) - 系统管理菜单(左侧)
		MenuEntity sys_manager_left_folder_menu = initNode(sys_manager_top_menu , MenuTypeConstants.MENU, "系统管理", "sys_manager_left_folder_menu", "icon-windows" , null);
		
		//系统管理菜单(左侧) - 菜单管理
		MenuEntity menu_manager_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "菜单管理", "menu_manager_menu", "icon-anchor" , "/views/menu/menuPage.html");
		
		//系统管理菜单(左侧) - word模板配置
		MenuEntity word_template_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "Word模板", "word_template_menu", "icon-file-word" , "/views/wordTemplate/wordTemplate.html");
		
		//系统管理菜单(左侧) - 标签库管理
		MenuEntity mark_lib_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "标签库管理", "mark_lib_menu", "icon-tags" , "/views/markLib/markLibListPage.html");
		
		//系统管理菜单(左侧) - 用户管理
		MenuEntity user_manager_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "用户管理", "user_manager_menu", "icon-user" , "/views/sysUser/sysUserListPage.html");
		
		//系统管理菜单(左侧) - 用户管理 - 子按钮
		MenuEntity addUserBtn = initNode(user_manager_menu, MenuTypeConstants.BUTTON, "新增用户", "addUserBtn" , null , "/sysUser/addSysUser");
		MenuEntity editUserBtn = initNode(user_manager_menu, MenuTypeConstants.BUTTON, "编辑用户", "editUserBtn" , null , "/sysUser/updateSysUser");
		MenuEntity resetPasswordBtn = initNode(user_manager_menu, MenuTypeConstants.BUTTON, "重置密码", "resetPasswordBtn" , null , "/sysUser/resetPassword");
		MenuEntity deleteUserBtn = initNode(user_manager_menu, MenuTypeConstants.BUTTON, "删除用户", "deleteUserBtn" , null , "/sysUser/deleteSysUserById");
		
		//系统管理菜单(左侧) - 角色管理
		MenuEntity role_manager_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "角色管理", "role_manager_menu", "icon-group" , "/views/sysRole/sysRoleListPage.html");
	
		//系统管理菜单(左侧) - 角色管理 - 子按钮
		MenuEntity addRoleBtn = initNode(role_manager_menu, MenuTypeConstants.BUTTON, "新增角色", "addRoleBtn" , null , "/sysRole/addSysRole");
		MenuEntity editRoleBtn = initNode(role_manager_menu, MenuTypeConstants.BUTTON, "编辑角色", "editRoleBtn" , null, "/sysRole/updateSysRole");
		MenuEntity roleBindMenuOpenWindowBtn = initNode(role_manager_menu, MenuTypeConstants.BUTTON, "权限" , "roleBindMenuOpenWindowBtn" , null , null);
		MenuEntity deleteRoleBtn = initNode(role_manager_menu, MenuTypeConstants.BUTTON, "删除角色", "deleteRoleBtn" , null, "/sysRole/deleteSysRoleById");
		MenuEntity roleBindUserOpenWindowBtn  = initNode(role_manager_menu, MenuTypeConstants.BUTTON, "绑定用户" ,  "roleBindUserOpenWindowBtn" , null , null);
		
		//系统管理菜单(左侧) - 权限 - 子按钮
		MenuEntity sureRoleBindMenuBtn = initNode(roleBindMenuOpenWindowBtn, MenuTypeConstants.BUTTON, "确定", "sureRoleBindMenuBtn", null , "/sysRole/roleBindMenus");

		//系统管理菜单(左侧) - 角色管理 - 绑定用户弹窗 - 子按钮
		MenuEntity roleBindBatchUserBtn = initNode(roleBindUserOpenWindowBtn, MenuTypeConstants.BUTTON, "批量绑定", "roleBindBatchUserBtn", null , "/sysRole/roleBindUsers");
		MenuEntity roleUnbindBatchUserBtn = initNode(roleBindUserOpenWindowBtn, MenuTypeConstants.BUTTON, "批量解绑", "roleUnbindBatchUserBtn", null , "/sysRole/roleUnbindUsers");
		MenuEntity roleBindUserBtn = initNode(roleBindUserOpenWindowBtn, MenuTypeConstants.BUTTON, "绑定", "roleBindUserBtn", null , "/sysRole/roleBindUsers");
		MenuEntity roleUnbindUserBtn = initNode(roleBindUserOpenWindowBtn, MenuTypeConstants.BUTTON, "解绑", "roleUnbindUserBtn", null , "/sysRole/roleUnbindUsers");
		
		//系统管理菜单(左侧) - 配置管理
		MenuEntity config_manager_menu = initNode(sys_manager_left_folder_menu , MenuTypeConstants.MENU, "配置管理", "config_manager_menu", "icon-cogs" , "/views/sysDict/sysDictListPage.html");

		log.info("初始化系统菜单end");
	}
	
	/**
	 * @function 初始化节点
	 * @author 肖荣辉
	 * @date 2023年12月20日
	*/
	public MenuEntity initNode(int menuType ,  String menuName , String menuNo , String icon) {
		return initNode(null, menuType, menuName, menuNo, icon , null);
	}
	
	/**
	 * @function 初始化节点
	 * @author 肖荣辉
	 * @date 2023年12月20日
	*/
	public MenuEntity initNode(int menuType ,  String menuName , String menuNo , String icon , String url) {
		return initNode(null, menuType, menuName, menuNo, icon , url);
	}
	
	/**
	 * @function 初始化节点
	 * @author 肖荣辉
	 * @date 2023年12月20日
	*/
	public MenuEntity initNode(MenuEntity parentNode , int menuType ,  String menuName , String menuNo) {
		return initNode(parentNode, menuType, menuName, menuNo, null , null);
	}
	
	/**
	 * @function 初始化节点
	 * @author 肖荣辉
	 * @date 2023年12月20日
	*/
	public MenuEntity initNode(MenuEntity parentNode , int menuType ,  String menuName , String menuNo , String icon , String url) {
		
		MenuEntity entity = createEntityIfMenuNoNotExist(menuNo);
		
		 entity.setName(menuName);
		 entity.setSortNo(entity.getId() == null ? SeqNoUtils.createMenuSeq() : entity.getSortNo());
		 entity.setIcon(icon);
		 entity.setUrl(url);
		 entity.setSysFlag(1);
		 entity.setType(menuType);
		 entity.setParentMenuId(parentNode == null ? null : parentNode.getId());
		 
		 if(entity.getId() == null) {
			 menuMapper.insert(entity);
		 }else {
			 menuMapper.updateById(entity);
		 }
		
		 String tip = MenuTypeConstants.BUTTON == menuType ? "按钮" : "菜单";
		 
		log.info("初始化{}【{}】成功" , tip , menuName);
		
		return entity;
	}
	
	/**
	 * @function 检测菜单编号是否存在
	 * @author 肖荣辉
	 * @date 2023年12月17日
	*/
	public void checkMenuNoExist(String oldMenuNo , String newMenuNo) {
		
		if(oldMenuNo != null && oldMenuNo.equals(newMenuNo))
			return;
		
		LambdaQueryWrapper<MenuEntity> queryWrapper = new LambdaQueryWrapper<MenuEntity>();
		
		queryWrapper.eq(MenuEntity::getMenuNo, newMenuNo);
		
		queryWrapper.last("limit 1");
		
		XAssert.isTrue(menuMapper.selectOne(queryWrapper) == null, "编号"+newMenuNo+"已经存在");
		
	}
	
	/**
	 * @function 如果编号不存在则创建一个
	 * @param menuNo
	 * @author 肖荣辉
	 * @date 2023年12月17日
	*/
	private MenuEntity createEntityIfMenuNoNotExist(String menuNo) {
		
		MenuEntity entity = findEntityByMenuNo(menuNo);
		
		entity = entity == null ? new MenuEntity() : entity;
		
		entity.setMenuNo(menuNo);
		
		return entity;
	}
	
	/**
	 * @function 根据菜单编号获取entity
	 * @param menuNo
	 * @author 肖荣辉
	 * @date 2023年12月17日
	*/
	public MenuEntity findEntityByMenuNo(String menuNo) {
		
		LambdaQueryWrapper<MenuEntity> queryWrapper = new LambdaQueryWrapper<MenuEntity>();
		
		queryWrapper.eq(MenuEntity::getMenuNo, menuNo);
		
		queryWrapper.last("limit 1");
		
		return menuMapper.selectOne(queryWrapper);
	}
	
	/**
	 * @function 新增Menu
	 * @param menuAddRequest
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	public Long addMenu(MenuAddRequest menuAddRequest) {
		
		//检查菜单编号是否存在
		checkMenuNoExist(null, menuAddRequest.getMenuNo());
		
		MenuEntity menuEntity = new MenuEntity();
		
		BeanUtil.copyProperties(menuAddRequest , menuEntity , CopyOptions.create().ignoreNullValue());
		
		if(menuAddRequest.getParentMenuId() != null) {
			MenuEntity parentEntity = menuMapper.selectById(menuAddRequest.getParentMenuId());
			XAssert.isTrue(parentEntity != null, "父级菜单id不合法");
		}
		
		menuEntity.setSortNo(SeqNoUtils.createMenuSeq());
		
		menuMapper.insert(menuEntity);
		
		return menuEntity.getId();
	}
	
	/**
	 * @function 获取菜单id的子孙后代节点
	 * @param menuId
	 * @author 肖荣辉
	 * @date 2023年12月14日
	*/
	public Set<Long> getDescendantsIds(Long menuId){
		
		LambdaQueryWrapper<MenuEntity> queryWrapper = new LambdaQueryWrapper<MenuEntity>();
		
		queryWrapper.select(MenuEntity::getId , MenuEntity::getParentMenuId);
		
		queryWrapper.isNotNull(MenuEntity::getParentMenuId);
		
		List<MenuEntity> list = menuMapper.selectList(queryWrapper);
		
		if(CollUtil.isEmpty(list))
			return new HashSet<Long>();
		
		Map<Long, List<MenuEntity>> parentIdEntityListMap = CollStreamUtil.groupByKey(list, MenuEntity::getParentMenuId);
		
		return getDescendantsIds(parentIdEntityListMap, CollUtil.newArrayList(menuId));
		
	}
	
	
	/**
	 * @function 根据父id的子孙后代节点ids
	 * @param parentId
	 * @author 肖荣辉
	 * @date 2023年12月14日
	*/
	public Set<Long> getDescendantsIds(Map<Long, List<MenuEntity>> parentIdEntityListMap, Collection<Long> parentIds){
		
		Set<Long> childrenIds = new HashSet<Long>();
		
		if(MapUtil.isEmpty(parentIdEntityListMap) || CollUtil.isEmpty(parentIds))
			return childrenIds;

		for(Long parentId : parentIds) {
			
			List<MenuEntity> list = parentIdEntityListMap.get(parentId);
			
			if(CollUtil.isEmpty(list)) continue;
			
			childrenIds.addAll(CollStreamUtil.toSet(list, MenuEntity::getId));
			
		}
		
		childrenIds.addAll(getDescendantsIds(parentIdEntityListMap, childrenIds));
		
		return childrenIds;
		
	}
	 
	/**
	 * @function 删除Menu
	 * @param id
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	@Transactional
	public void deleteMenuById(Long id) {
		
		if(id == null)
			throw new BusinessException("id不能为空");
			
		MenuEntity menuEntity = menuMapper.selectById(id);
		
		if(menuEntity == null)
			throw new BusinessException("id不合法");
		
		XAssert.isTrue(menuEntity.getSysFlag() == 0, "系统菜单不可以删除");
		
		//若是按钮 , 直接删除
		if(menuEntity.getType() == MenuTypeConstants.BUTTON) {
			
			//删除自己
			menuMapper.deleteById(id);
			
			//删除关联关系
			roleVsMenuService.deleteRoleVsMenuByMenuId(CollUtil.newArrayList(id));
		}
		
		//若是菜单 , 子孙后代都要删除
		Set<Long> menuIds = getDescendantsIds(id);
		
		//自己也要删除
		menuIds.add(id	);
		
		//删除菜单
		menuMapper.deleteBatchIds(menuIds);
		
		//删除关联关系
		roleVsMenuService.deleteRoleVsMenuByMenuId(CollUtil.newArrayList(menuIds));
		
		//操作轨迹标题
		OperateTraceAspect.setTitle(menuEntity.getName());
	}

	/**
	 * @function 修改Menu
	 * @param menuUpdateRequest
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	public void updateMenu(MenuUpdateRequest menuUpdateRequest) {
		
		if(menuUpdateRequest.getId() == null)
			throw new BusinessException("id不能为空");
		
		MenuEntity menuEntity = menuMapper.selectById(menuUpdateRequest.getId());
		
		if(menuEntity == null)
			throw new BusinessException("id不合法");
		
		XAssert.isTrue(menuEntity.getSysFlag() == 0, "系统菜单不可以编辑");
		
		//检查菜单编号是否存在
		checkMenuNoExist(menuEntity.getMenuNo() , menuUpdateRequest.getMenuNo());
		
		BeanUtil.copyProperties(menuUpdateRequest , menuEntity , CopyOptions.create().ignoreNullValue());
		
		menuMapper.updateById(menuEntity);
		
	}

	/**
	 * @function 根据ID查询Menu Entity
	 * @param id
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	public MenuEntity findMenuEntityById(Long id) {
		
		if(id == null)
			throw new BusinessException("id不能为空");
			
		MenuEntity menuEntity = menuMapper.selectById(id);
		
		return menuEntity;
	}
	
	/**
	 * @function 根据ID查询Menu DTO
	 * @param id
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	public MenuDTO findMenuById(Long id) {
		
		if(id == null)
			throw new BusinessException("id不能为空");
	
		MenuEntity menuEntity = menuMapper.selectById(id);
		
		MenuDTO  menuDTO = BeanUtil.toBean(menuEntity , MenuDTO.class);
		
		return menuDTO;
	}

	/**
	 * @function 根据MenuQueryVo查询Menu列表
	 * @param menuQueryRequest
	 * @author 肖荣辉
	 * @date 2023-12-08 15:17:26
	*/
	public CommonResult<CommonPage<MenuDTO>> findMenuList(MenuQueryRequest menuQueryRequest) {
		
		Page<MenuEntity> page = menuQueryRequest.createPage();

		QueryWrapper<MenuEntity> queryWrapper = menuQueryRequest.createQuery();
		
		menuMapper.selectPage(page, queryWrapper);
		
		List<MenuDTO> dtoList = BeanUtil.copyToList(page.getRecords() , MenuDTO.class);
		
		return CommonResult.success(CommonPage.create(menuQueryRequest.getPageNum() , menuQueryRequest.getPageSize() , dtoList, page.getTotal()));
	}
	
	/**
	 * @function 获取菜单树状结构
	 * @author 肖荣辉
	 * @date 2023年12月8日
	*/
	public List<MenuTreeDTO> findMenuTreeList(){
		
		List<MenuEntity> entityList = menuMapper.selectList(new LambdaQueryWrapper<MenuEntity>());
		
		if(CollUtil.isEmpty(entityList))
			return new ArrayList<MenuTreeDTO>();
		
		return convert2tree(entityList);
	}
	
    /**
   	 * @function 获取角色绑定的系统菜单
   	 * @author 肖荣辉
   	 * @date 2023-12-08 15:17:26
   	*/
	public List<MenuTreeDTO> findRoleBindMenuTreeList(Long roleId){
		
		XAssert.isTrue(roleId != null, "角色id不能为空");
		
		List<MenuEntity> entityList = menuMapper.selectList(new LambdaQueryWrapper<MenuEntity>());
		
		if(CollUtil.isEmpty(entityList))
			return new ArrayList<MenuTreeDTO>();
		
        List<MenuTreeDTO> list = BeanUtil.copyToList(entityList, MenuTreeDTO.class);
        
        //查询当前角色有哪些菜单ids
        Set<Long> menuIds =  roleVsMenuService.getMenuIdsByRoleId(roleId);
        
        if(CollUtil.isEmpty(menuIds))
        	return convertDTO2tree(list);
        
        //角色绑定的设置标志
        list.forEach(item->{item.setBindFlag(menuIds.contains(item.getId()));});
		
		return convertDTO2tree(list);
	}
	
	/**
	 * @function 获取用户拥有的菜单id集合
	 * @author 肖荣辉
	 * @date 2023年12月8日
	*/
	public Set<Long> getUserMenuIds() {
		
		Set<Long> roleIds = sysRoleService.getUserRoleIds();
		
		if(CollUtil.isEmpty(roleIds))
			return new HashSet<Long>();
		
		return 	roleVsMenuService.getMenuIdsByRoleIds(roleIds);
	}
	
	/**
	 * @function 获取用户拥有的菜单id集合
	 * @author 肖荣辉
	 * @date 2023年12月8日
	 */
	public Set<Long> getMenuIdsByUserId(Long userId) {
		
		Set<Long> roleIds = sysRoleService.getRoleIdsByUserId(userId);
		
		if(CollUtil.isEmpty(roleIds))
			return new HashSet<Long>();
		
		return 	roleVsMenuService.getMenuIdsByRoleIds(roleIds);
	}
	
	/**
	 * @function 获取用户拥有的菜单id集合
	 * @author 肖荣辉
	 * @date 2023年12月8日
	*/
	public Set<String> getMenuNosByUserId(Long userId) {
		
		Set<Long> menuIds = getMenuIdsByUserId(userId);
		
		if(CollUtil.isEmpty(menuIds))
			return new HashSet<String>();
		
		List<MenuEntity> list = menuMapper.selectBatchIds(menuIds);
	
		return CollStreamUtil.toSet(list , MenuEntity::getMenuNo);
	}
	
	/**
	 * @function 获取用户拥有的菜单entitys
	 * @author 肖荣辉
	 * @date 2023年12月8日
	*/
	public List<MenuEntity> getMenuEntitysByUserId(Long userId) {
		
		Set<Long> menuIds = getMenuIdsByUserId(userId);
		
		if(CollUtil.isEmpty(menuIds))
			return new ArrayList<MenuEntity>();
		
		List<MenuEntity> list = menuMapper.selectBatchIds(menuIds);
	
		return list;
	}
	
	/**
	 * @function 获取用户有权限的菜单列表
	 * @author 肖荣辉
	 * @date 2023年12月8日
	*/
	public List<MenuTreeDTO> getUserMenu(){
		
		List<MenuEntity> entityList = menuMapper.selectList(new LambdaQueryWrapper<MenuEntity>());
		
		if(CollUtil.isEmpty(entityList))
			return new ArrayList<MenuTreeDTO>();

		SysUserDTO user = LoginUtils.getUser();
		
		if(user.isAdmin())
			return convert2tree(entityList);
		
		//找到用户拥有的菜单id集合
		Set<Long> menuIds = getUserMenuIds();
		
		if(CollUtil.isEmpty(menuIds))
			return new ArrayList<MenuTreeDTO>();
		
		//挑选出有权限的id
		List<MenuEntity> pickList = entityList.stream().filter(item->menuIds.contains(item.getId())).collect(Collectors.toList());
		
		if(CollUtil.isEmpty(pickList))
			return new ArrayList<MenuTreeDTO>();
		
		return convert2tree(pickList);
	}
	
    /**
     * @function 根据节点序号进行排序
     * @author 肖荣辉
     * @date 2023年6月16日
     */
    public  List<MenuTreeDTO> sortNodeBySortNo(List<MenuTreeDTO> list) {

        if (CollectionUtils.isEmpty(list))
            return list;

        //正序排列
        Collections.sort(list, new Comparator<MenuTreeDTO>() {

            @Override
            public int compare(MenuTreeDTO o1, MenuTreeDTO o2) {
                if (o1.getSortNo().equals(o2.getSortNo()))
                    return 0;

                return o1.getSortNo() > o2.getSortNo() ? 1 : -1;
            }

        });

        /*孩子节点也排序*/
        for (MenuTreeDTO item : list) {

            if (CollectionUtils.isNotEmpty(item.getChildren()))
                item.setChildren(sortNodeBySortNo(item.getChildren()));
        }

        return list;

    }

    /**
     * @function 转化成树结构
     * @author 肖荣辉
     * @date 2023年6月16日
     */
    public  List<MenuTreeDTO> convert2tree(List<MenuEntity> entityList) {

        List<MenuTreeDTO> list = BeanUtil.copyToList(entityList, MenuTreeDTO.class);

        return convertDTO2tree(list);
    }
    
    /**
     * @function 转化成树结构
     * @author 肖荣辉
     * @date 2023年6月16日
     */
    public  List<MenuTreeDTO> convertDTO2tree(List<MenuTreeDTO> list) {

        Map<Long, MenuTreeDTO> map = new HashMap<Long, MenuTreeDTO>();

        List<MenuTreeDTO> tree = new ArrayList<MenuTreeDTO>();

        if (CollectionUtils.isEmpty(list))
            return tree;

        //先摊开
        for (MenuTreeDTO item : list) {

            Long id = item.getId();
            Long parentId = item.getParentMenuId();

            map.put(id, item);

            //顶级的放到数组里
            if (parentId == null)
                tree.add(item);
        }

        /*再绑到父亲的children下面去*/
        Collection<MenuTreeDTO> values = map.values();

        for (MenuTreeDTO item : values) {

            Long parentId = item.getParentMenuId();

            MenuTreeDTO parent = map.get(parentId);

            if (parent == null)
                continue;

            if (parent.getChildren() == null)
                parent.setChildren(new ArrayList<MenuTreeDTO>());

            parent.getChildren().add(item);
        }

        return sortNodeBySortNo(tree);
    }
	
}
